//import java.util.Arrays;
//import java.util.Date;
//import java.sql.Date;
import java.util.*; //*是通配符，它可以导入包中的所有类，就可以不用写指定要导入的类名
//但是更建议 显式的指定要导入的类名，不然容易出现歧义，例如 util和sql中都有Date类，那我们在使用的时候就不知道到底是使用util中的Date类还是sql中的
//import java.sql.*;
//那如果想要导入sql中的Date类和util中的Date类，就只能使用完整的类名（java.sql.Date）去使用，否则与util中的Date类冲突，
//即只要是类名冲突的，其中一个只能用完整类名去访问而不用import语句导入包的方式

//静态导入包
import static java.lang.Math.*;
//意思是：导入Math类中的所有静态成员（包括静态方法和静态变量），在后续代码中可以直接使用这些静态成员，而不需要写类名Math。
//import static java.lang.System.*;

//导入自定义包
import com.abc.www.TestPackage;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User:张熳
 * Date:2025-08-19
 * Time:16:10
 */
//类和对象

class Student{  //就像我们现在定义的Student类，前面没有任何访问限定符修饰的，就是default（缺省）访问限定符的意思，即什么都不写时的默认权限
    //成员变量
    //char ch; //默认权限，在同一包中的同一类汇或者不同类都可以使用
    //String n; //默认权限
    //成员方法
    /*int fun2(int age){  //默认权限
        return age;
    }*/
    private String name;//姓名   将被public修饰改为被private修饰，表示私有成员变量，只能在同一包的同一类中使用
    private int age;//年龄
    private String stuNum;//学号
    //静态成员（类成员）
    public static String className;//班级

    //如果想要在Student类外有私有成员变量的访问权限，一般通过类提供的公共方法实现
    //这些方法被叫做getter方法（访问器-用于获取/读取私有成员变量的值，命名规范：get + 变量名首字母大写）和setter方法（修改器-用于修改
    // 私有成员变量的值（可添加验证逻辑，例如if等）,命名规范：set + 变量名首字母大写）
  /*  public String getName(){
        return this.name;
    }
    public void setName(String name){
        this.name = name;
    }*/
    //和构造方法一样，这些公共方法也有快捷键，选定要访问的私有成员变量，就可以快速创建
    //右键选择 Generate -> Getter and Setter -> 选定变量开始创建
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getStuNum() {
        return stuNum;
    }

    public void setStuNum(String stuNum) {
        this.stuNum = stuNum;
    }

    //成员方法
    public void eat(){
        System.out.println(this.name + " 在吃早餐 ");
    }
    public void doClass(){
        fun();//在本类中可以调用该私有成员方法，而类外就不可以
        System.out.println(this.name + " 在上课 ");
    }
    //private修饰的私有成员方法
    private void fun(){
        System.out.println("这个方法是为本类其他访问服务的，不对外公开");
    }

    //构造方法
    public Student(){
        //this("张三",10,"30");
        System.out.println("不带参数的构造方法");
    }
    public Student(String name, int age, String stuNum) {
        this.name = name;
        this.age = age;
        this.stuNum = stuNum;
        //System.out.println("带3个参数的构造方法");
    }

    //验证类成员在所有实例化对象中是共享的
    public void func(){
        System.out.println(" 姓名: "+this.name+" 年龄: "+this.age+" 学号: "+ this.stuNum+" 班级: "+className);
        //类成员不需要this去表示要访问的是当前对象，它只拷贝一份，在所有的类的实例化对象中都是共享的，
        //如果通过类名去修改它，它的值也是可变的
    }
}

public class Test {
    public static void main(String[] args) {
        //static成员
        Student student1 = new Student("zhangsan",10,"1234");
        //student1.className = "1班";//通过对象的引用访问
        Student.className = "1班";//通过类的访问（访问更合理，className变量属于类的，不是对象的，通过类访问更好）
        student1.func();

        Student student2 = new Student("lisi",12,"1256");
        //student2.className = "1班";
        student2.func();

        //验证类成员属于类的，而不是属于对象的
        Student student = null;
        student.className = "1班";
        System.out.println(student.className);
    }
    //导入包中的类
    public static void main5(String[] args) {
        //自定义包 - 想要在这里使用自定义包，需要进行导入
        TestPackage testPackage = new TestPackage();
        testPackage.test();
        System.out.println(testPackage.a);
    }
    public static void main4(String[] args) {
        //使用import static导入包中静态的方法和字段
        double x = 30;
        double y = 40;
        double result = Math.sqrt(Math.pow(x,2)+Math.pow(y,2));
        System.out.println(result);
        //静态导入的方式写起来更方便一些,但是一般不这样搞
        double result1 = sqrt(pow(x,2)+pow(y,2));
        //out.println(result1);
    }
    public static void main3(String[] args) {
        int[] array = {1,2,3,4,5,6};
        System.out.println(Arrays.toString(array));//写下Arrays这个类后，按回车就会在顶部出现 java.util这个包中的Arrays类供使用
        //一般是用import语句导入包，但是也可以使用不导入包的方式使用类中的方法，即将完整的包路径写出来
        /*java.util.Arrays.toString(array);
        java.util.Date date = new java.util.Date();*/
        //但是还是建议使用import语句导入
        Date date1 = new Date();
        System.out.println(date1.getTime());//得到一个毫秒级别的时间戳

        //为了import java.util.*;不与import java.sql.*;发生冲突，就只能使用完整的类名
        /*java.util.Date date1 = new java.util.Date();
        System.out.println(date1.getTime());*/

        //如果想要导入sql中的Date类和util中的Date类，其中一个只能用完整类名去访问而不用import语句（无论是用 * 或者显示指定导入类名的方式）
        // 导入包的方式
        java.sql.Date date2 = new java.sql.Date(10);//与util.Data冲突，用完整的类名
    }
    public static void main2(String[] args) {
        Student student1 = new Student();

        /*student1.name = "zhangsan";//由于成员变量是被private访问控制，那么在不同类中就不能被使用，因此这里会报错
        student1.age = 10;
        student1.stuNum = "12345";
        System.out.println(student1.name);
        System.out.println(student1.age);
        System.out.println(student1.stuNum);*/

        //通过公共方法访问私有成员变量
        student1.setName("zhangsan");
        System.out.println(student1.getName());
        student1.setAge(10);
        System.out.println(student1.getAge());
        student1.setStuNum("123456");
        System.out.println(student1.getStuNum());

        student1.doClass();//通过公共方法doClass间接调用/访问私有成员方法fun
    }
    public static void main1(String[] args) {
        //对象的实例化
        /*Student student1 = new Student();
        student1.name = "zhangsan";
        student1.age = 10;
        student1.stuNum = "12345";
        student1.doClass();
        student1.eat();
        System.out.println("===============");
        Student student2 = new Student();
        student2.name = "lisi";
        student2.age = 11;
        student2.stuNum = "166345";
        student2.doClass();
        student2.eat();*/
    }

}
